/// 错误处理

//! 错误处理模块
//!
//! 定义 CNC 代码生成过程中可能出现的所有错误类型

use thiserror::Error;
use std::path::PathBuf;
use serde_json;
use crate::core::model::{Component, ComponentType};

/// CNC 处理过程中的错误
#[derive(Debug, Error)]
pub enum ProcessingError {
    /// 组件参数错误
    #[error("参数错误: {0}")]
    ParameterError(String),

    /// 找不到合适的刀具
    #[error("找不到合适的刀具: {0}")]
    ToolNotFound(String),

    /// 几何计算错误
    #[error("几何计算错误: {0}")]
    GeometryError(String),

    /// 策略错误
    #[error("策略错误: {0}")]
    StrategyError(String),

    /// 输入/输出错误
    #[error("I/O 错误: {0}")]
    IoError(#[from] std::io::Error),

    /// 序列化/反序列化错误
    #[error("序列化错误: {0}")]
    SerializationError(#[from] serde_json::Error),

    /// 配置错误
    #[error("配置错误: {0}")]
    ConfigError(String),

    /// 找不到组件策略
    #[error("找不到组件策略: {component_type:?} (组件 ID: {component_id})")]
    StrategyNotFound {
        component_type: ComponentType,
        component_id: String,
    },

    /// 参数缺失
    #[error("参数缺失: {param_name} (组件 ID: {component_id}, 类型: {component_type:?})")]
    MissingParameter {
        param_name: String,
        component_id: String,
        component_type: ComponentType,
    },

    /// 参数类型错误
    #[error("参数类型错误: {param_name} 应为 {expected_type}, 实际为 {actual_value} (组件 ID: {component_id})")]
    ParameterTypeError {
        param_name: String,
        expected_type: String,
        actual_value: String,
        component_id: String,
    },

    /// 路径规划错误
    #[error("路径规划错误: {0}")]
    PathPlanningError(String),

    /// 碰撞检测错误
    #[error("碰撞检测错误: {0}")]
    CollisionError(String),

    /// 后处理错误
    #[error("后处理错误: {0}")]
    PostProcessingError(String),

    /// 自定义错误
    #[error("自定义错误: {0}")]
    Custom(String),
}

/// 结果类型别名，简化错误处理
pub type ProcessingResult<T> = Result<T, ProcessingError>;

// 为错误提供更多上下文的方法
impl ProcessingError {
    /// 为错误添加上下文信息
    pub fn with_context(self, context: &str) -> Self {
        match self {
            ProcessingError::ParameterError(msg) =>
                ProcessingError::ParameterError(format!("{}: {}", context, msg)),
            ProcessingError::StrategyError(msg) =>
                ProcessingError::StrategyError(format!("{}: {}", context, msg)),
            // 其他类型的错误可以类似处理...
            other => other,
        }
    }

    /// 从组件创建策略未找到错误
    pub fn strategy_not_found(component: &Component) -> Self {
        ProcessingError::StrategyNotFound {
            component_type: component.component_type.clone(),
            component_id: component.id.clone(),
        }
    }

    /// 创建参数缺失错误
    pub fn missing_parameter(component: &Component, param_name: &str) -> Self {
        ProcessingError::MissingParameter {
            param_name: param_name.to_string(),
            component_id: component.id.clone(),
            component_type: component.component_type.clone(),
        }
    }

    /// 创建参数类型错误
    pub fn parameter_type_error(
        component: &Component,
        param_name: &str,
        expected_type: &str,
        actual_value: &str
    ) -> Self {
        ProcessingError::ParameterTypeError {
            param_name: param_name.to_string(),
            expected_type: expected_type.to_string(),
            actual_value: actual_value.to_string(),
            component_id: component.id.clone(),
        }
    }
}